home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d26 / stages12.arc / MOVES.C < prev    next >
Text File  |  1991-05-22  |  12KB  |  443 lines
  1. #include "header.h"
  2. #include "file.h"
  3.  
  4. #define FACTOR    1000
  5.  
  6. /************************************************************************/
  7. /**    cycle movement calculations                       **/
  8. /************************************************************************/
  9. /*  includes the functions:
  10.     forward
  11.     backward
  12.     cellcheck
  13. */
  14. static cellcheck (int cellnum, int part, int *ok, int *flagp, char dir,
  15.           double days, double life, char *opstr);
  16.  
  17.  
  18. /********************************/
  19. /*     function: forward    */
  20. /********************************/
  21. /* returns 1 if all movements ok,
  22.    returns 0 if any movement caused spermiation */
  23. forward (initseq, index, third, days, cell, ok, endspotp, opstr)
  24.   int initseq, index;
  25.   double third, days;
  26.   int *cell, *ok, *endspotp;
  27.   char *opstr;
  28. {
  29.   double d[4];            /* four day counts, starting    */
  30.                 /* from beg, 1/3, 2/3, and end    */
  31.                 /* of current stage        */
  32.   /* the following array duplicates the d[4] array.  it is used to track
  33.      stages after the particular cell has been spermiated */
  34.   double dd[4];
  35.   double life[4];        /* time til spermiation, from    */
  36.                   /* the beg, 1/3, 2/3 and end    */
  37.   int i;            /* cell sequence number        */
  38.   int j;            /* stage array counter        */
  39.   int k;            /* iteration var        */
  40.   int here;            /* temp var for cell stage #    */
  41.   int strsetq;            /* error opstr set yet?  if so,    */
  42.                 /* don't set it again          */
  43.  
  44. #if (DEBUG > 4)
  45. #if PC
  46.   clrscr1(3);
  47.   gotoxy(1, 1);
  48.   cprintf("%sforward:  entering", tab);
  49.   hitreturn(1);
  50. #else
  51.   printf("\tforward:  entering\n");
  52. #endif
  53. #endif
  54.   strsetq = 0;
  55.   *endspotp = 0;
  56.   /*  d[0] starts .001 of the way into the stage[index] */
  57.   life[0] = stage[index]*0.999;
  58.   life[1] = 2*third;
  59.   life[2] = third;
  60.   /*  d[3] starts .001 from the end of the stage[index] */
  61.   life[3] = stage[index]*0.001;
  62.   for ( k=0; k<4; k++ ) {
  63.     ok[k] = 1;
  64.     d[k] = days - life[k];    /* d vars            */
  65.     dd[k] = d[k];
  66.     cell[k] = 0;        /* init cell vars to anything    */
  67.   } /* for k */
  68.  
  69. #if (DEBUG > 4)
  70. #if PC
  71.     clrscr1(1);
  72.     gotoxy(1, 5);
  73.     cprintf("%sforward: life: [0]=<%lf>  [1]=<%lf>", tab, life[0], life[1]);
  74.     gotoxy(1, 6);
  75.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, life[2], life[3]);
  76.     gotoxy(1, 7);
  77.     cprintf("%sforward:    d: [0]=<%lf>  [1]=<%lf>", tab, d[0], d[1]);
  78.     gotoxy(1, 8);
  79.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, d[2], d[3]);
  80.     gotoxy(1, 9);
  81.     cprintf("%sforward:   dd: [0]=<%lf>  [1]=<%lf>", tab, dd[0], dd[1]);
  82.     gotoxy(1, 10);
  83.     cprintf("%s               [2]=<%lf>  [3]=<%lf>", tab, dd[2], dd[3]);
  84.     hitreturn(1);
  85. #else
  86.   printf("\t: \n");
  87. #endif
  88. #endif
  89.  
  90.   for ( k=0; k<4; k++ ) {
  91.     i = initseq;
  92.     j = index;
  93.     while ((d[k] > 0.0) && ok[k]) {
  94. #if (DEBUG > 4)
  95. #if PC
  96.       clrscr1(1);
  97.       gotoxy(1, 5);
  98.       cprintf("%sforward:  i=<%d>  CellNames[i]=<%s>",
  99.           tab, i, CellNames[i]);
  100.       hitreturn(1);
  101. #else
  102.       printf("\tforward:  i=<%d>  CellNames[i]=<%s>\n", i, CellNames[i]);
  103. #endif
  104. #endif
  105.       here = getcellstg(CellNames[i]);
  106.       if (here == INVALID) {
  107. #if PC
  108.     clrscr1(1);
  109.     gotoxy(1, 5);
  110.     cprintf("%sforward:  Illegal value, here=<%d>", tab, here);
  111.     gotoxy(1, 7);
  112.     cprintf("%s          Sorry, aborting.", tab);
  113. #else
  114.     printf("\tforward:  Illegal value, here=<%d>\n", here);
  115.     printf("\t          Sorry, aborting.");
  116. #endif
  117.     printexit(601);
  118.       } /* if INVALID */
  119.  
  120.       /* skip cells in same stage as current cell, to get to first successor
  121.      cell in the next stage, but only move fwd til i > MaxCellIndex+1
  122.      '+1' because of epididymis */
  123.       while ((++i <= MaxCellIndex+1) && (getcellstg(CellNames[i])==here));
  124.       cellcheck(i, k, ok, &strsetq, 'F', days, life[k], opstr);
  125.  
  126.       switch (ok[k]) {
  127.       case 1:    /* cell ok, still in cycle */
  128.     j = ++j % NumStages;
  129.     if (d[k] < stage[j]) {
  130.       /* move ends @ this stage: find which 3d moves ends in */
  131.       if (d[k] <= (stage[j]/3.0)) {
  132.         *endspotp = 1;
  133.       } else {
  134.         if (d[k] <= (2.0*stage[j]/3.0)) {
  135.           *endspotp = 2;
  136.         } else {
  137.           *endspotp = 3;
  138.         }
  139.       }
  140.     }
  141.     life[k] += stage[j];
  142.     d[k] -= stage[j];
  143.     dd[k] = d[k];
  144.     break;
  145.       case 2:    /* cell into epididymis */
  146.     life[k] += EpiTime;
  147.     d[k] -= EpiTime;
  148.     /* for stage tracking, just use stage index j and ignore cell */
  149.     j = ++j % NumStages;
  150.     dd[k] -= stage[j];
  151.     break;
  152.       case 0:
  153.       default:  /* ejaculate: but keep going, to get final stage reached */
  154.     j = ++j % NumStages;
  155.     dd[k] -= stage[j];
  156.     break;
  157.       } /* switch */
  158.     } /* while d[k] */
  159.  
  160. #if (DEBUG > 4)
  161. #if PC
  162.     clrscr1(1);
  163.     gotoxy(1, 5);
  164.     cprintf("%sforward: k=<%d>  ok[k]=<%d>  cell#=<%d>  stg#=<%d>",
  165.         tab, k, ok[k], i, j);
  166.     hitreturn(1);
  167. #else
  168.     printf("\tforward: \n");
  169. #endif
  170. #endif
  171.  
  172.     /* stopped moving: set cell or stage reached */
  173.     switch (ok[k]) {
  174.     case 1:    /* reached normal cell */
  175.       cell[k] = i;
  176.       break;
  177.     case 2:    /* reached epi: use stage that would've been reached */
  178.       cell[k] = j;
  179.       break;
  180.     case 0:
  181.     default:    /* ejaculated: set cell[k] to stage reached */
  182.       cell[k] = j;
  183.       break;
  184.     } /* switch */
  185.   } /* for k */
  186.  
  187. #if (DEBUG > 4)
  188. #if PC
  189.   clrscr1(1);
  190.   gotoxy(1, 4);
  191.   cprintf("%sforward:  mid-function", tab);
  192.   gotoxy(1, 5);
  193.   cprintf("%sforward:  cell:  [0]=<%d>  [1]=<%d>", tab, cell[0], cell[1]);
  194.   gotoxy(1, 6);
  195.   cprintf("%s                 [2]=<%d>  [3]=<%d>", tab, cell[2], cell[3]);
  196.   hitreturn(1);
  197. #else
  198.   printf("\t: \n");
  199. #endif
  200. #endif
  201.  
  202.   /* for those starting pts which ended up with epi/ejact cells, continue
  203.      to track stages */
  204.   for ( k=0; k<4; k++ ) {
  205.     if (ok[k] != 1) {
  206.       j = cell[k];    /* the stage this starting pt left off at */
  207.       while (dd[k] > 0.0) {
  208.     j = ++j % NumStages;
  209.     dd[k] -= stage[j];
  210.       } /* while dd[k] */
  211.  
  212.       /* stopped moving: set stage reached */
  213.       cell[k] = j+1;
  214.     } /* if */
  215.   } /* for k */
  216. #if (DEBUG > 4)
  217. #if PC
  218.   clrscr1(1);
  219.   gotoxy(1, 4);
  220.   cprintf("%sforward:  leaving", tab);
  221.   gotoxy(1, 5);
  222.   cprintf("%sforward:  cell:  [0]=<%d>  [1]=<%d>", tab, cell[0], cell[1]);
  223.   gotoxy(1, 6);
  224.   cprintf("%s                 [2]=<%d>  [3]=<%d>", tab, cell[2], cell[3]);
  225.   gotoxy(1, 7);
  226.   cprintf("%s          endspot=<%d>", tab, *endspotp);
  227.   hitreturn(1);
  228. #else
  229.   printf("\tforward:  leaving\n");
  230. #endif
  231. #endif
  232.   return(0);
  233. } /* forward */
  234.  
  235. /********************************/
  236. /*     function: backward    */
  237. /********************************/
  238. /* returns 1 if all movements ok,
  239.    returns 0 if any movement went further back than when
  240.    cell entered cycle */
  241. backward (initseq, index, third, days, cell, ok, endspotp, opstr)
  242.   int initseq, index;
  243.   double third, days;
  244.   int *cell, *ok, *endspotp;
  245.   char *opstr;
  246. {
  247.   double d[4];            /* four day counts, starting    */
  248.                   /* from beg, 1/3, 2/3, and end     */
  249.                 /* of current stage        */
  250.   /* the following array duplicates the d[4] array.  it is used to track
  251.      stages after the particular cell has been spermiated.     */
  252.   double dd[4];
  253.   double life[4];        /* time til cell released, from    */
  254.                   /* the beg, 1/3, 2/3 and end    */
  255.   int i;            /* cell sequence number        */
  256.   int j;            /* stage array counter        */
  257.   int k;            /* iteration var        */
  258.   int here;            /* temp var for cell stage #    */
  259.   int strsetq;            /* error opstr set yet?        */
  260.  
  261.   strsetq = 0;
  262.   *endspotp = 3;
  263.   /*  d[3] starts .001 from the end of the stage[index] */
  264.   life[3] = stage[index]*0.999;
  265.   life[2] = 2*third;
  266.   life[1] = third;
  267.   /*  d[0] starts .001 of the way into the stage[index] */
  268.   life[0] = stage[index]*0.001;
  269.   for ( k=0; k<4; k++ ) {
  270.     ok[k] = 1;            /* init ok vars    */
  271.     d[k] = days - life[k];    /* init d vars    */
  272.     dd[k] = d[k];
  273.     cell[k] = 0;        /* init cell vars to anything */
  274.   }
  275.  
  276.   for ( k=3; k>-1; k-- ) {
  277.     i = initseq;
  278.     j = index;
  279.     while ((d[k] > 0) && ok[k]) {
  280.       here = getcellstg(CellNames[i]);
  281.       /* skip cells in same stage as current cell, to get to first successor
  282.      cell in the next stage, but only move bwd til i = 0 */
  283.       while ((--i >= 0) && (getcellstg(CellNames[i])==here));
  284.       cellcheck(i, k, ok, &strsetq, 'B', days, life[k], opstr);
  285.  
  286.       if (j==0)
  287.     j = MaxStage;
  288.       else
  289.     j = --j % NumStages;
  290.  
  291.       switch (ok[k]) {
  292.       case 1:    /* cell ok, still in cycle */
  293.     if (d[k] < stage[j]) {
  294.       /* move ends @ this stage: find which 3d moves ends in */
  295.       if (d[k] <= (stage[j]/3.0)) {
  296.         *endspotp = 3;
  297.       } else {
  298.         if (d[k] <= (2.0*stage[j]/3.0)) {
  299.           *endspotp = 2;
  300.         } else {
  301.           *endspotp = 1;
  302.         }
  303.       }
  304.     }
  305.     life[k] += stage[j];
  306.     d[k] -= stage[j];
  307.     dd[k] = d[k];
  308.     break;
  309.       case 0:
  310.       default:  /* pre-entry: but keep going, to get final stage reached */
  311.     dd[k] -= stage[j];
  312.     break;
  313.       } /* switch */
  314.     } /* while d[k] */
  315.  
  316.     /* stopped moving: set cell reached */
  317.     switch (ok[k]) {
  318.     case 1:    /* reached normal cell */
  319.       cell[k] = i;
  320.       break;
  321.     case 0:
  322.     default:    /* pre-entry: set cell[k] to stage reached */
  323.       cell[k] = j;
  324.       break;
  325.     } /* switch */
  326.   } /* for k */
  327.  
  328.   /* for those starting pts which ended up as pre-entry, continue to
  329.      track stages */
  330.   for ( k=3; k>-1; k-- ) {
  331.     if (! ok[k]) {
  332.       j = cell[k];    /* the stage this starting pt left off at */
  333.       while (dd[k] > 0) {
  334.     if (j==0)
  335.       j = MaxStage;
  336.     else
  337.       j = --j % NumStages;
  338.     dd[k] -= stage[j];
  339.       } /* while dd[k] */
  340.  
  341.       /* stopped moving: set stage reached */
  342.       cell[k] = j+1;
  343.     } /* if */
  344.   } /* for k */
  345. #if (DEBUG > 4)
  346. #if PC
  347.   clrscr1(1);
  348.   gotoxy(1, 4);
  349.   cprintf("%sbackward:  leaving", tab);
  350.   gotoxy(1, 5);
  351.   cprintf("%sbackward:  cell:  [0]=<%d>  [1]=<%d>", tab, cell[0], cell[1]);
  352.   gotoxy(1, 6);
  353.   cprintf("%s                  [2]=<%d>  [3]=<%d>", tab, cell[2], cell[3]);
  354.   gotoxy(1, 7);
  355.   cprintf("%s             ok:  [0]=<%d>  [1]=<%d>", tab, ok[0], ok[1]);
  356.   gotoxy(1, 8);
  357.   cprintf("%s                  [2]=<%d>  [3]=<%d>", tab, ok[2], ok[3]);
  358.   gotoxy(1, 9);
  359.   cprintf("%s           endspot=<%d>", tab, *endspotp);
  360.   hitreturn(1);
  361. #else
  362.   printf("\tbackward:  leaving\n");
  363. #endif
  364. #endif
  365.   return(0);
  366. } /* backward */
  367.  
  368. /********************************/
  369. /*     function: cellcheck     */
  370. /********************************/
  371. /* checks if cell moved to is valid
  372.    ok[part] set to:  0: not ok: cell ejaculated or pre-entry
  373.                 1: cell ok
  374.              2: cell in epididymis */
  375. /* static means that this function is only used within this file
  376.    saves space in the executable file */
  377. static cellcheck (cellnum, part, ok, flagp, dir, days, life, opstr)
  378.   int cellnum, part, *ok, *flagp;
  379.   char dir;
  380.   double days;
  381.   double life;    /* = #days since spermiation, or
  382.              #days since cell entered spermatogenesis */
  383.   char *opstr;
  384. {
  385.   double tmp;
  386.   char tmpstr[20];
  387.  
  388.   if (((dir=='F') && (cellnum > MaxCellIndex)) ||
  389.       ((dir=='B') && (cellnum < CycleStart))) {
  390.     if (cellnum == (MaxCellIndex+1))
  391.       /* ok: cell moved into the epididymis */
  392.       ok[part] = 2;
  393.     else
  394.       /* not ok: cell ejaculated or pre-entry */
  395.       ok[part] = 0;
  396.  
  397.     if (! *flagp) {
  398.       if (dir=='F') {
  399.     *flagp = 1;
  400.     tmp = (days-life)/CycleTime;
  401.     sprintf(opstr, "Spermiation occurred after %.2lf day", life);
  402.     /* want to see if life, a double, is within 1/FACTOR of 1 */
  403.     if ((int) (FACTOR*life + 0.5) != FACTOR)
  404.       strcat(opstr, "s");
  405.     sprintf(tmpstr, "; %.2lf cycle", tmp);
  406.     strcat(opstr, tmpstr);
  407.     if ((int) (FACTOR*tmp + 0.5) != FACTOR)
  408.       strcat(opstr,"s have ");
  409.     else
  410.       strcat(opstr, " has ");
  411.     strcat(opstr, "since passed");
  412.       }
  413.       if (dir=='B') {
  414.     *flagp = 1;
  415.     tmp = life/CycleTime;
  416.     sprintf(opstr, "Cell entered spermatogenesis cycle %.2lf day", life);
  417.     if ((int) (FACTOR*life + 0.5) != FACTOR)
  418.       strcat(opstr, "s");
  419.     sprintf(tmpstr, " = %.2lf cycle", tmp);
  420.     strcat(opstr, tmpstr);
  421.     if ((int) (FACTOR*tmp + 0.5) != FACTOR)
  422.       strcat(opstr, "s");
  423.     strcat(opstr, " ago");
  424. #if (DEBUG > 4)
  425. #if PC
  426.   clrscr1(1);
  427.   gotoxy(1, 5);
  428.   cprintf("%scellcheck:  cellnum=<%d>", tab, cellnum);
  429.   gotoxy(1, 6);
  430.   cprintf("%s            opstr=<%s>", tab, opstr);
  431.   hitreturn(1);
  432. #else
  433.   printf("\t: \n");
  434. #endif
  435. #endif
  436.       }
  437.     } /* if *flagp */
  438.   } else
  439.     /* ok: normal cell */
  440.     ok[part] = 1;
  441.   return(0);
  442. } /* cellcheck */
  443.